const { PrismaClient } = require('@prisma/client');
const prisma = new PrismaClient();

/**
 * 计算日期范围
 * @param {number} days - 天数
 * @returns {Date} 开始日期
 */
const calculateStartDate = (days) => {
  const startDate = new Date();
  startDate.setDate(startDate.getDate() - days);
  startDate.setHours(0, 0, 0, 0);
  return startDate;
};

/**
 * 初始化日期范围内的每一天
 * @param {number} days - 天数
 * @returns {Object} 日期对象
 */
const initializeDateRange = (days) => {
  const dateRange = {};
  const currentDate = new Date();

  for (let i = 0; i < days; i++) {
    const date = new Date();
    date.setDate(currentDate.getDate() - i);
    const dateString = date.toISOString().split('T')[0];
    dateRange[dateString] = 0;
  }

  return dateRange;
};

/**
 * 获取销售数据
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getSalesData = async (req, res) => {
  try {
    // 获取日期范围参数，默认为最近7天
    const days = parseInt(req.query.days) || 7;
    
    // 计算开始日期
    const startDate = calculateStartDate(days);
    
    // 查询订单数据
    const orders = await prisma.order.findMany({
      where: {
        createdAt: {
          gte: startDate
        },
        status: {
          in: ['paid', 'completed'] // 统计已支付和已完成的订单
        }
      },
      include: {
        items: true
      }
    }).catch(err => {
      console.error('查询订单数据出错:', err);
      return []; // 查询失败时返回空数组
    });
    
    // 按天统计销售额
    const salesByDay = initializeDateRange(days);
    
    // 统计每天的销售额
    orders.forEach(order => {
      const dateString = order.createdAt.toISOString().split('T')[0];
      if (salesByDay[dateString] !== undefined) {
        salesByDay[dateString] += parseFloat(order.total || 0);
      }
    });
    
    // 转换为数组格式，按日期排序
    const salesData = Object.entries(salesByDay)
      .map(([date, amount]) => ({ date, amount }))
      .sort((a, b) => a.date.localeCompare(b.date));
    
    // 计算总销售额和日均销售额
    const totalSales = salesData.reduce((sum, item) => sum + item.amount, 0);
    const averageDailySales = totalSales / days;
    
    // 按支付方式统计
    const salesByPaymentMethod = {};
    
    // 获取每个订单的支付记录
    const ordersWithPayments = await prisma.order.findMany({
      where: {
        createdAt: {
          gte: startDate
        },
        status: {
          in: ['paid', 'completed']
        }
      },
      include: {
        payments: true
      }
    }).catch(err => {
      console.error('查询订单支付数据出错:', err);
      return []; // 查询失败时返回空数组
    });
    
    // 统计每种支付方式的销售额
    ordersWithPayments.forEach(order => {
      if (!order.payments) return;
      
      order.payments.forEach(payment => {
        const method = payment.method || 'unknown';
        if (!salesByPaymentMethod[method]) {
          salesByPaymentMethod[method] = 0;
        }
        salesByPaymentMethod[method] += parseFloat(payment.amount || 0);
      });
    });
    
    return res.json({
      status: 'success',
      data: {
        salesData,
        totalSales,
        averageDailySales,
        salesByPaymentMethod
      }
    });
  } catch (error) {
    console.error('获取销售数据失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '获取销售数据失败',
      error: error.message
    });
  }
};

/**
 * 获取订单数据
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getOrdersData = async (req, res) => {
  try {
    // 获取日期范围参数，默认为最近7天
    const days = parseInt(req.query.days) || 7;
    
    // 计算开始日期
    const startDate = new Date();
    startDate.setDate(startDate.getDate() - days);
    startDate.setHours(0, 0, 0, 0);
    
    // 查询订单数据
    const orders = await prisma.order.findMany({
      where: {
        createdAt: {
          gte: startDate
        }
      }
    }).catch(err => {
      console.error('查询订单数据出错:', err);
      return []; // 查询失败时返回空数组
    });
    
    // 按天统计订单数量
    const ordersByDay = {};
    const currentDate = new Date();
    
    // 初始化日期范围内的每一天
    for (let i = 0; i < days; i++) {
      const date = new Date();
      date.setDate(currentDate.getDate() - i);
      const dateString = date.toISOString().split('T')[0];
      ordersByDay[dateString] = 0;
    }
    
    // 统计每天的订单数量
    orders.forEach(order => {
      const dateString = order.createdAt.toISOString().split('T')[0];
      if (ordersByDay[dateString] !== undefined) {
        ordersByDay[dateString]++;
      }
    });
    
    // 转换为数组格式，按日期排序
    const ordersData = Object.entries(ordersByDay)
      .map(([date, count]) => ({ date, count }))
      .sort((a, b) => a.date.localeCompare(b.date));
    
    // 统计订单状态
    const ordersByStatus = {};
    orders.forEach(order => {
      const status = order.status || 'unknown';
      if (!ordersByStatus[status]) {
        ordersByStatus[status] = 0;
      }
      ordersByStatus[status]++;
    });
    
    // 统计平均订单金额
    const totalAmount = orders.reduce((sum, order) => sum + parseFloat(order.total || 0), 0);
    const averageOrderAmount = orders.length > 0 ? totalAmount / orders.length : 0;
    
    return res.json({
      status: 'success',
      data: {
        ordersData,
        totalOrders: orders.length,
        ordersByStatus,
        averageOrderAmount
      }
    });
  } catch (error) {
    console.error('获取订单数据失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '获取订单数据失败',
      error: error.message
    });
  }
};

/**
 * 获取产品数据
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getProductsData = async (req, res) => {
  try {
    // 获取日期范围参数，默认为最近30天（产品统计通常需要更长时间范围）
    const days = parseInt(req.query.days) || 30;
    
    // 计算开始日期
    const startDate = new Date();
    startDate.setDate(startDate.getDate() - days);
    startDate.setHours(0, 0, 0, 0);
    
    // 查询订单项数据，统计产品销量
    const orderItems = await prisma.orderItem.findMany({
      where: {
        order: {
          createdAt: {
            gte: startDate
          },
          status: {
            in: ['paid', 'completed'] // 统计已支付和已完成的订单
          }
        }
      },
      include: {
        product: true,
        order: true
      }
    }).catch(err => {
      console.error('查询订单项数据出错:', err);
      return []; // 查询失败时返回空数组
    });
    
    // 按产品统计销量和销售额
    const productSales = {};
    
    orderItems.forEach(item => {
      if (!item.product) return;
      
      const productId = item.productId;
      if (!productSales[productId]) {
        productSales[productId] = {
          id: productId,
          name: item.product.name,
          quantity: 0,
          amount: 0
        };
      }
      
      productSales[productId].quantity += item.quantity;
      productSales[productId].amount += parseFloat(item.price || 0) * item.quantity;
    });
    
    // 转换为数组并按销售额排序（显示所有有销售记录的商品）
    const topProducts = Object.values(productSales)
      .sort((a, b) => b.amount - a.amount); // 按销售额排序，显示所有商品
    
    // 查询所有产品
    const products = await prisma.product.findMany().catch(err => {
      console.error('查询产品数据出错:', err);
      return []; // 查询失败时返回空数组
    });
    
    // 按分类统计产品数量
    const productsByCategory = {};
    const categories = await prisma.category.findMany().catch(err => {
      console.error('查询分类数据出错:', err);
      return []; // 查询失败时返回空数组
    });
    
    categories.forEach(category => {
      productsByCategory[category.id] = {
        name: category.name,
        count: 0
      };
    });
    
    products.forEach(product => {
      if (product.categoryId && productsByCategory[product.categoryId]) {
        productsByCategory[product.categoryId].count++;
      }
    });
    
    return res.json({
      status: 'success',
      data: {
        topProducts,
        totalProducts: products.length,
        productsByCategory: Object.values(productsByCategory)
      }
    });
  } catch (error) {
    console.error('获取产品数据失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '获取产品数据失败',
      error: error.message
    });
  }
};

/**
 * 获取渠道销售数据
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getChannelData = async (req, res) => {
  try {
    let startDate, endDate;
    const queryType = req.query.type;
    
    if (queryType === 'month' && req.query.month) {
      // 按月查询
      const [year, month] = req.query.month.split('-').map(Number);
      
      // 验证月份格式
      if (isNaN(year) || isNaN(month) || month < 1 || month > 12) {
        return res.status(400).json({
          status: 'error',
          message: '无效的月份格式，请使用YYYY-MM格式'
        });
      }
      
      // 设置月份的起始日期（当月1日）
      startDate = new Date(year, month - 1, 1);
      
      // 设置月份的结束日期（下月1日减1毫秒，即当月最后一天的23:59:59.999）
      endDate = new Date(year, month, 1);
      endDate.setMilliseconds(-1);
      
      console.log(`按月查询渠道数据：${year}年${month}月，开始日期：${startDate.toISOString()}，结束日期：${endDate.toISOString()}`);
    } else {
      // 按天数查询（默认方式）
      const days = parseInt(req.query.days) || 7;
      
      // 计算开始日期
      startDate = new Date();
      startDate.setDate(startDate.getDate() - days);
      startDate.setHours(0, 0, 0, 0);
      
      // 结束日期为现在
      endDate = new Date();
      
      console.log(`按天数查询渠道数据：最近${days}天，开始日期：${startDate.toISOString()}`);
    }
    
    // 查询订单数据，包括渠道信息
    const orders = await prisma.order.findMany({
      where: {
        createdAt: {
          gte: startDate,
          ...(endDate && { lte: endDate })
        },
        status: {
          in: ['paid', 'completed'] // 统计已支付和已完成的订单
        }
      },
      include: {
        channel: true, // 包含渠道信息
        items: true
      }
    }).catch(err => {
      console.error('查询订单渠道数据出错:', err);
      return []; // 查询失败时返回空数组
    });
    
    // 查询所有渠道
    const channels = await prisma.channel.findMany().catch(err => {
      console.error('查询渠道数据出错:', err);
      return []; // 查询失败时返回空数组
    });
    
    // 初始化渠道销售数据
    const channelData = {};
    channels.forEach(channel => {
      channelData[channel.id] = {
        id: channel.id,
        name: channel.name,
        totalAmount: 0,
        orderCount: 0,
        averageAmount: 0
      };
    });
    
    // 统计每个渠道的销售额和订单数量
    orders.forEach(order => {
      const channelId = order.channelId;
      if (channelId && channelData[channelId]) {
        channelData[channelId].totalAmount += parseFloat(order.total || 0);
        channelData[channelId].orderCount++;
      }
    });
    
    // 计算每个渠道的平均订单金额
    Object.values(channelData).forEach(channel => {
      if (channel.orderCount > 0) {
        channel.averageAmount = channel.totalAmount / channel.orderCount;
      }
    });
    
    // 转换为数组并按销售额排序
    const channelSales = Object.values(channelData)
      .sort((a, b) => b.totalAmount - a.totalAmount);
    
    // 返回查询参数信息
    const queryInfo = queryType === 'month' 
      ? { month: req.query.month, type: 'month' }
      : { days: parseInt(req.query.days) || 7 };
    
    return res.json({
      status: 'success',
      data: {
        channelSales,
        ...queryInfo
      }
    });
  } catch (error) {
    console.error('获取渠道数据失败:', error);
    return res.status(500).json({
      status: 'error',
      message: '获取渠道数据失败',
      error: error.message
    });
  }
}; 